home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_c49.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  4.9 KB  |  321 lines

  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_c.h"
  9. void*se_ma96(int argc,...){
  10. T96*m;
  11. va_list pa;
  12. T0**s;
  13. m=malloc(sizeof(*m));
  14. *m=M96;
  15. if(argc){
  16. s=malloc(argc*sizeof(*s));
  17. m->_storage=s;
  18. m->_capacity=argc;
  19. m->_lower=1;
  20. m->_upper=argc;
  21. va_start(pa,argc);
  22. while(argc--){
  23. *(s++)=((void*)(va_arg(pa,char*)));
  24. }
  25. va_end(pa);
  26. }
  27. return m;}
  28. void*se_ma608(int argc,...){
  29. T608*m;
  30. va_list pa;
  31. T0**s;
  32. m=malloc(sizeof(*m));
  33. *m=M608;
  34. if(argc){
  35. s=malloc(argc*sizeof(*s));
  36. m->_storage=s;
  37. m->_capacity=argc;
  38. m->_lower=1;
  39. m->_upper=argc;
  40. va_start(pa,argc);
  41. while(argc--){
  42. *(s++)=((void*)(va_arg(pa,char*)));
  43. }
  44. va_end(pa);
  45. }
  46. return m;}
  47. void*se_ma419(int argc,...){
  48. T419*m;
  49. va_list pa;
  50. T0**s;
  51. m=malloc(sizeof(*m));
  52. *m=M419;
  53. if(argc){
  54. s=malloc(argc*sizeof(*s));
  55. m->_storage=s;
  56. m->_capacity=argc;
  57. m->_lower=1;
  58. m->_upper=argc;
  59. va_start(pa,argc);
  60. while(argc--){
  61. *(s++)=((void*)(va_arg(pa,char*)));
  62. }
  63. va_end(pa);
  64. }
  65. return m;}
  66. void*se_ma552(int argc,...){
  67. T552*m;
  68. va_list pa;
  69. T0**s;
  70. m=malloc(sizeof(*m));
  71. *m=M552;
  72. if(argc){
  73. s=malloc(argc*sizeof(*s));
  74. m->_storage=s;
  75. m->_capacity=argc;
  76. m->_lower=1;
  77. m->_upper=argc;
  78. va_start(pa,argc);
  79. while(argc--){
  80. *(s++)=((void*)(va_arg(pa,char*)));
  81. }
  82. va_end(pa);
  83. }
  84. return m;}
  85. void*se_ma681(int argc,...){
  86. T681*m;
  87. va_list pa;
  88. T0**s;
  89. m=malloc(sizeof(*m));
  90. *m=M681;
  91. if(argc){
  92. s=malloc(argc*sizeof(*s));
  93. m->_storage=s;
  94. m->_capacity=argc;
  95. m->_lower=1;
  96. m->_upper=argc;
  97. va_start(pa,argc);
  98. while(argc--){
  99. *(s++)=((void*)(va_arg(pa,char*)));
  100. }
  101. va_end(pa);
  102. }
  103. return m;}
  104. void*se_ma235(int argc,...){
  105. T235*m;
  106. va_list pa;
  107. T0**s;
  108. m=malloc(sizeof(*m));
  109. *m=M235;
  110. if(argc){
  111. s=malloc(argc*sizeof(*s));
  112. m->_storage=s;
  113. m->_capacity=argc;
  114. m->_lower=1;
  115. m->_upper=argc;
  116. va_start(pa,argc);
  117. while(argc--){
  118. *(s++)=((void*)(va_arg(pa,char*)));
  119. }
  120. va_end(pa);
  121. }
  122. return m;}
  123. void*se_ma429(int argc,...){
  124. T429*m;
  125. va_list pa;
  126. T2*s;
  127. m=malloc(sizeof(*m));
  128. *m=M429;
  129. if(argc){
  130. s=malloc(argc*sizeof(*s));
  131. m->_storage=s;
  132. m->_capacity=argc;
  133. m->_lower=1;
  134. m->_upper=argc;
  135. va_start(pa,argc);
  136. while(argc--){
  137. *(s++)=va_arg(pa,int);
  138. }
  139. va_end(pa);
  140. }
  141. return m;}
  142. void*se_ma365(int argc,...){
  143. T365*m;
  144. va_list pa;
  145. T0**s;
  146. m=malloc(sizeof(*m));
  147. *m=M365;
  148. if(argc){
  149. s=malloc(argc*sizeof(*s));
  150. m->_storage=s;
  151. m->_capacity=argc;
  152. m->_lower=1;
  153. m->_upper=argc;
  154. va_start(pa,argc);
  155. while(argc--){
  156. *(s++)=((void*)(va_arg(pa,char*)));
  157. }
  158. va_end(pa);
  159. }
  160. return m;}
  161. void*se_ma495(int argc,...){
  162. T495*m;
  163. va_list pa;
  164. T0**s;
  165. m=malloc(sizeof(*m));
  166. *m=M495;
  167. if(argc){
  168. s=malloc(argc*sizeof(*s));
  169. m->_storage=s;
  170. m->_capacity=argc;
  171. m->_lower=1;
  172. m->_upper=argc;
  173. va_start(pa,argc);
  174. while(argc--){
  175. *(s++)=((void*)(va_arg(pa,char*)));
  176. }
  177. va_end(pa);
  178. }
  179. return m;}
  180. void*se_ma948(int argc,...){
  181. T948*m;
  182. va_list pa;
  183. T0**s;
  184. m=malloc(sizeof(*m));
  185. *m=M948;
  186. if(argc){
  187. s=malloc(argc*sizeof(*s));
  188. m->_storage=s;
  189. m->_capacity=argc;
  190. m->_lower=1;
  191. m->_upper=argc;
  192. va_start(pa,argc);
  193. while(argc--){
  194. *(s++)=((void*)(va_arg(pa,char*)));
  195. }
  196. va_end(pa);
  197. }
  198. return m;}
  199. void*se_ma52(int argc,...){
  200. T52*m;
  201. va_list pa;
  202. T0**s;
  203. m=malloc(sizeof(*m));
  204. *m=M52;
  205. if(argc){
  206. s=malloc(argc*sizeof(*s));
  207. m->_storage=s;
  208. m->_capacity=argc;
  209. m->_lower=1;
  210. m->_upper=argc;
  211. va_start(pa,argc);
  212. while(argc--){
  213. *(s++)=((void*)(va_arg(pa,char*)));
  214. }
  215. va_end(pa);
  216. }
  217. return m;}
  218. void*se_ma247(int argc,...){
  219. T247*m;
  220. va_list pa;
  221. T0**s;
  222. m=malloc(sizeof(*m));
  223. *m=M247;
  224. if(argc){
  225. s=malloc(argc*sizeof(*s));
  226. m->_storage=s;
  227. m->_capacity=argc;
  228. m->_lower=1;
  229. m->_upper=argc;
  230. va_start(pa,argc);
  231. while(argc--){
  232. *(s++)=((void*)(va_arg(pa,char*)));
  233. }
  234. va_end(pa);
  235. }
  236. return m;}
  237. void*se_ma764(int argc,...){
  238. T764*m;
  239. va_list pa;
  240. T0**s;
  241. m=malloc(sizeof(*m));
  242. *m=M764;
  243. if(argc){
  244. s=malloc(argc*sizeof(*s));
  245. m->_storage=s;
  246. m->_capacity=argc;
  247. m->_lower=1;
  248. m->_upper=argc;
  249. va_start(pa,argc);
  250. while(argc--){
  251. *(s++)=((void*)(va_arg(pa,char*)));
  252. }
  253. va_end(pa);
  254. }
  255. return m;}
  256. void*se_ma381(int argc,...){
  257. T381*m;
  258. va_list pa;
  259. T0**s;
  260. m=malloc(sizeof(*m));
  261. *m=M381;
  262. if(argc){
  263. s=malloc(argc*sizeof(*s));
  264. m->_storage=s;
  265. m->_capacity=argc;
  266. m->_lower=1;
  267. m->_upper=argc;
  268. va_start(pa,argc);
  269. while(argc--){
  270. *(s++)=((void*)(va_arg(pa,char*)));
  271. }
  272. va_end(pa);
  273. }
  274. return m;}
  275. void*se_ma701(int argc,...){
  276. T701*m;
  277. va_list pa;
  278. T0**s;
  279. m=malloc(sizeof(*m));
  280. *m=M701;
  281. if(argc){
  282. s=malloc(argc*sizeof(*s));
  283. m->_storage=s;
  284. m->_capacity=argc;
  285. m->_lower=1;
  286. m->_upper=argc;
  287. va_start(pa,argc);
  288. while(argc--){
  289. *(s++)=((void*)(va_arg(pa,char*)));
  290. }
  291. va_end(pa);
  292. }
  293. return m;}
  294. void*se_ma382(int argc,...){
  295. T382*m;
  296. va_list pa;
  297. T0**s;
  298. m=malloc(sizeof(*m));
  299. *m=M382;
  300. if(argc){
  301. s=malloc(argc*sizeof(*s));
  302. m->_storage=s;
  303. m->_capacity=argc;
  304. m->_lower=1;
  305. m->_upper=argc;
  306. va_start(pa,argc);
  307. while(argc--){
  308. *(s++)=((void*)(va_arg(pa,char*)));
  309. }
  310. va_end(pa);
  311. }
  312. return m;}
  313. void rsp(void){
  314. printf("Eiffel program crash at run time.\n");
  315. printf("No trace when using option \"-boost\"\n");}
  316. void sigrsp(int sig){
  317. printf("Received signal %d (man signal).\n",sig);
  318. rsp();
  319. exit(1);}
  320.  
  321.